import axios from "axios";

/**
 * Axios 操作者
 * */
export default function (baseUrl) {

    // 请求方式种类
    const requestMethodType = {
        get: "get",
        post: "post",
    }

    // 异常处理类型
    const exceptionHandleType = {
        request: "request",
        response: "response"
    }

    // 异常类型
    const exceptionType = {
        noPermission: "身份失效",
        serviceException: "服务器内部错误",
        timeOut: "请求超时",
        badRequest: "请求地址错误",
        requestFailed: "请求失败",
    }

    // 默认配置
    let defaultConfig = {
        // Host地址
        baseURL: baseUrl,
        // Api地址
        url: '',
        // 请求头
        headers: {
            'Content-Type': 'application/json;charset=utf-8'
        },
        // 请求数据
        data: {},
        // 请求超时的毫秒数
        timeout: 0,
        // `auth` 表示应该使用 HTTP 基础验证，并提供凭据
        // 这将设置一个 `Authorization` 头，覆写掉现有的任意使用 `headers` 设置的自定义 `Authorization`头
        // auth: {
        //     username: 'janedoe',
        //     password: 's00pers3cret'
        // },
        // 服务器响应的数据类型 'arraybuffer', 'blob', 'document', 'json', 'text', 'stream'
        responseType: 'json',
        // 定义代理服务器
        // proxy: {
        //     host: '127.0.0.1',
        //     port: 9000,
        //     auth: {
        //         username: 'mikeymike',
        //         password: 'rapunz3l'
        //     }
        // },
    };

    // 添加请求拦截器
    axios.interceptors.request.use(function (config) {
        // 在发送请求之前做些什么
        return config;
    }, function (error) {
        // 对请求错误做些什么
        return Promise.reject(error);
    });

    // 添加响应拦截器
    axios.interceptors.response.use(
        // 处理请求成功
        function (response) {

            // TODO 请求响应
            return response.data ? response.data : response;
        },
        // 异常处理
        function (error) {

            return exceptionHandle(exceptionHandleType.response, error);
        });


    /**
     * 执行响应处理
     * @param response - 响应信息
     * @param handleParam - 处理参数
     * */
    let resposeHandle = function (response, handleParam) {

        // 设置处理参数
        handleParam = Object.assign({
            badRequestFunc: () => {
            },
            noPermissionFunc: () => {
            },
            timeOutFunc: () => {
            },
            serviceExceptionFunc: () => {
            },
            requestFailedFunc: () => {
            }
        }, handleParam);

        if (!response) {
            handleParam.requestFailedFunc();
            return;
        }

        switch (response.status) {
            // 错误请求
            case 400:
            case 403:
                handleParam.badRequestFunc();
                break;
            // 身份失效
            case 401:
                handleParam.noPermissionFunc();
                break;
            // 请求超时
            case 408:
                handleParam.timeOutFunc();
                break;
            // 服务器错误
            case 500:
                handleParam.serviceExceptionFunc();
                break;
            // 其他错误
            default:
                handleParam.requestFailedFunc();
                break;
        }
    }

    /**
     * 异常处理
     * @param type - 处理类型
     * @param error - 异常
     * */
    let exceptionHandle = function (type, error) {

        // 输出日志
        printRequestErrorLog(error);

        // 执行响应处理
        resposeHandle(error.response,
            {
                // 错误请求
                badRequestFunc: () => {
                    // TODO
                },
                // 身份失效
                noPermissionFunc: () => {
                    // TODO
                },
                // 请求超时
                timeOutFunc: () => {
                    // TODO
                },
                // 服务器错误
                serviceExceptionFunc: () => {
                    // TODO
                },
                // 其他错误
                requestFailedFunc: () => {
                    // TODO
                }
            });

        // 终端当前 promise链
        return new Promise(() => {
        });
    }

    /**
     * 打印请求日志
     * @param response - 响应参数
     * */
    let printRequestLog = function (error) {

        if (!error.response || !error.config)
            return;

        console.log("RequestUrl:", `${error.response.request.responseURL}`);
        console.log("RequestMethod:", error.config.method);
        console.log("RequestKey:", '');
        console.log("RequestData:", error.config.data);
        console.log("RequestSettings:", error.config);
        console.log("ResponseStatus:", error.response.status);
        console.log("ResponseData:", error.response.data);
        console.log("--------");
    }

    /**
     * 打印错误请求日志
     * @param error - 错误消息
     * */
    let printRequestErrorLog = function (error) {
        // 实例化 处理异常种类
        let errorMessage = "";

        // 执行响应处理
        resposeHandle(error.response,
            {
                // 错误请求
                badRequestFunc: () => {
                    errorMessage = exceptionType.badRequest;
                },
                // 身份失效
                noPermissionFunc: () => {
                    errorMessage = exceptionType.noPermission;
                },
                // 请求超时
                timeOutFunc: () => {
                    errorMessage = exceptionType.timeOut;
                },
                // 服务器错误
                serviceExceptionFunc: () => {
                    errorMessage = exceptionType.serviceException;
                },
                // 其他错误
                requestFailedFunc: () => {
                    errorMessage = exceptionType.requestFailed;
                }
            });

        // 设置异常消息
        let customErrorMessage = error.response && error.response.config.customErrorMessage ? error.response.config.customErrorMessage : "";
        errorMessage = customErrorMessage != "" ? customErrorMessage : errorMessage

        // 打印日志
        console.log("[requestError]：", errorMessage);
        printRequestLog(error);
    }

    /**
     * 请求
     * @param method - 请求方式
     * @param url - 请求地址
     * @param data - 请求数据
     * @param customErrorMessage - 自定义错误消息
     * @param isNeedKey - 是否需要键
     * */
    let request = async function (method, url, data, customErrorMessage = "", isNeedKey = true) {

        // 设置请求头
        let headers = Object.assign(defaultConfig.headers, {});

        // 设置配置项
        let config = Object.assign(defaultConfig, {
            // 请求地址
            url,
            // 请求方法
            method,
            // 请求头
            headers,
            // 请求数据
            data: method == requestMethodType.get ? {} : data,
            params: method == requestMethodType.get ? data : {},
            // 自定义错误消息
            customErrorMessage,
        })

        // 执行请求
        let result = await axios.request(config);
        return result;
    }

    /**
     * Get 请求
     * @param url - 请求地址
     * @param data - 请求数据
     * @param customErrorMessage - 自定义错误消息
     * @param isNeedKey - 是否需要键
     * */
    let get = async function (url, data, customErrorMessage = "", isNeedKey = true) {
        return await request(requestMethodType.get, url, data, customErrorMessage, isNeedKey);
    }

    /**
     * Post 请求
     * @param url - 请求地址
     * @param data - 请求数据
     * @param customErrorMessage - 自定义错误消息
     * @param isNeedKey - 是否需要键
     * */
    let post = async function (url, data, customErrorMessage = "", isNeedKey = true) {
        return await request(requestMethodType.post, url, data, customErrorMessage, isNeedKey);
    }


    return {
        get,
        post
    }

}